//package health_system.health_system.service;
//
//import health_system.health_system.entity.*;
//import health_system.health_system.exception.ChatAccessDeniedException;
//import health_system.health_system.exception.ChatRoomException;
//import health_system.health_system.repository.*;
//import jakarta.persistence.EntityNotFoundException;
//import jakarta.transaction.Transactional;
//import lombok.RequiredArgsConstructor;
//import lombok.extern.slf4j.Slf4j;
//
//import org.springframework.data.domain.Page;
//import org.springframework.data.domain.Pageable;
//import org.springframework.stereotype.Service;
//
//import java.util.HashSet;
//import java.util.List;
//import java.util.Optional;
//import java.util.Set;
//import java.util.stream.Collectors;
//
//@Service
//@RequiredArgsConstructor
//@Slf4j
//public class ChatRoomService {
//
//    private final ChatRoomRepository chatRoomRepository;
//    private final UserRepository userRepository;
////    private final DoctorRepository doctorRepository;
////    private final PatientRepository patientRepository;
//    private final ChatMessageRepository chatMessageRepository;
//    private final MessageReadStatusRepository messageReadStatusRepository;
////    private final NotificationService notificationService;
//    private final FileStorageService fileStorageService;
//
//    /**
//     * 获取用户的所有聊天室
//     */
//    public List<ChatRoom> getUserChatRooms(Long userId) {
//        User user = getUserById(userId);
//        return chatRoomRepository.findByParticipant(user);
//    }
//
//    /**
//     * 分页获取用户的聊天室
//     */
//    public Page<ChatRoom> getUserChatRoomsPaginated(Long userId, Pageable pageable) {
//        User user = getUserById(userId);
//        return chatRoomRepository.findByParticipant(user, pageable);
//    }
//
//    /**
//     * 获取用户的群聊
//     */
//    public List<ChatRoom> getUserGroupChats(Long userId) {
//        User user = getUserById(userId);
//        return chatRoomRepository.findGroupChatsByParticipant(user);
//    }
//
//    /**
//     * 获取拥有未读消息的聊天室
//     */
//    public List<ChatRoom> getChatRoomsWithUnreadMessages(Long userId) {
//        User user = getUserById(userId);
//        return chatRoomRepository.findChatRoomsWithUnreadMessages(user);
//    }
//
//    /**
//     * 计算用户有多少个有未读消息的聊天室
//     */
//    public Long countChatRoomsWithUnreadMessages(Long userId) {
//        User user = getUserById(userId);
//        return chatRoomRepository.countChatRoomsWithUnreadMessages(user);
//    }
//
//    /**
//     * 搜索聊天室
//     */
//    public List<ChatRoom> searchChatRooms(Long userId, String searchTerm) {
//        User user = getUserById(userId);
//        return chatRoomRepository.searchChatRooms(user, searchTerm);
//    }
//
//    /**
//     * 获取聊天室详情
//     */
//    public ChatRoom getChatRoomById(Long chatRoomId, Long userId) {
//        ChatRoom chatRoom = chatRoomRepository.findById(chatRoomId)
//                .orElseThrow(() -> new EntityNotFoundException("聊天室不存在，ID: " + chatRoomId));
//
//        User user = getUserById(userId);
//        validateChatRoomAccess(chatRoom, user);
//
//        return chatRoom;
//    }
//
//    /**
//     * 创建私聊聊天室
//     */
//    @Transactional
//    public ChatRoom createPrivateChatRoom(Long user1Id, Long user2Id) {
//        User user1 = getUserById(user1Id);
//        User user2 = getUserById(user2Id);
//
//        // 检查是否已存在私聊聊天室
//        Optional<ChatRoom> existingChatRoom = chatRoomRepository.findOneOnOneChatRoom(user1, user2);
//        if (existingChatRoom.isPresent()) {
//            return existingChatRoom.get();
//        }
//
//        // 创建新的私聊聊天室
//        ChatRoom chatRoom = new ChatRoom();
//        chatRoom.setChatType(ChatRoom.ChatType.PRIVATE);
//        chatRoom.setCreator(user1);
//
//        // 添加参与者
//        Set<User> participants = new HashSet<>();
//        participants.add(user1);
//        participants.add(user2);
//        chatRoom.setParticipants(participants);
//
//        return chatRoomRepository.save(chatRoom);
//    }
//
//    /**
//     * 创建或获取医生-患者聊天室
//     */
//    @Transactional
//    public ChatRoom createOrGetDoctorPatientChatRoom(Long doctorId, Long patientId) {
////        Doctor doctor = getDoctorById(doctorId);
////        Patient patient = getPatientById(patientId);
//
//        // 检查是否已存在医生-患者聊天室
//        Optional<ChatRoom> existingChatRoom = chatRoomRepository.findDoctorPatientChatRoom(doctorId, patientId);
//        if (existingChatRoom.isPresent()) {
//            return existingChatRoom.get();
//        }
//
//        // 创建新的医生-患者聊天室
//        ChatRoom chatRoom = new ChatRoom();
//        chatRoom.setChatType(ChatRoom.ChatType.PRIVATE);
//        chatRoom.setCreator(doctor);
//
//        // 添加参与者
//        Set<User> participants = new HashSet<>();
//        participants.add(doctor);
//        participants.add(patient);
//        chatRoom.setParticipants(participants);
//
//        return chatRoomRepository.save(chatRoom);
//    }
//
//    /**
//     * 创建群聊
//     */
//    @Transactional
//    public ChatRoom createGroupChatRoom(Long creatorId, String groupName, List<Long> participantIds, byte[] groupAvatar) {
//        User creator = getUserById(creatorId);
//
//        if (groupName == null || groupName.trim().isEmpty()) {
//            throw new IllegalArgumentException("群聊名称不能为空");
//        }
//
//        if (participantIds == null || participantIds.isEmpty()) {
//            throw new IllegalArgumentException("群聊必须至少有一个参与者");
//        }
//
//        // 创建新的群聊聊天室
//        ChatRoom chatRoom = new ChatRoom();
//        chatRoom.setChatType(ChatRoom.ChatType.GROUP);
//        chatRoom.setCreator(creator);
//        chatRoom.setGroupName(groupName);
//
//        // 如果有群头像，保存并设置URL
//        if (groupAvatar != null && groupAvatar.length > 0) {
//            try {
//                String avatarUrl = fileStorageService.storeMediaFile(groupAvatar, "group_avatar.jpg", "image");
//                chatRoom.setGroupAvatar(avatarUrl);
//            } catch (Exception e) {
//                log.error("保存群头像失败", e);
//                // 继续创建群聊，但没有头像
//            }
//        }
//
//        // 添加参与者
//        Set<User> participants = new HashSet<>();
//        participants.add(creator); // 创建者一定会被加入群聊
//
//        for (Long participantId : participantIds) {
//            // 跳过创建者ID，因为已经添加了
//            if (!participantId.equals(creatorId)) {
//                User participant = getUserById(participantId);
//                participants.add(participant);
//            }
//        }
//
//        chatRoom.setParticipants(participants);
//
//        ChatRoom savedChatRoom = chatRoomRepository.save(chatRoom);
//
//        // 通知所有参与者被添加到群聊
//        for (User participant : participants) {
//            if (!participant.getId().equals(creatorId)) {
//                try {
//                    notificationService.sendChatRoomActivityNotification(
//                            savedChatRoom, "JOIN", creator, participant);
//                } catch (Exception e) {
//                    log.error("发送群聊加入通知失败，用户ID: {}", participant.getId(), e);
//                }
//            }
//        }
//
//        return savedChatRoom;
//    }
//
//    /**
//     * 添加用户到群聊
//     */
//    @Transactional
//    public ChatRoom addParticipantToGroupChat(Long chatRoomId, Long userId, Long targetUserId) {
//        ChatRoom chatRoom = getChatRoomById(chatRoomId);
//        User user = getUserById(userId);
//        User targetUser = getUserById(targetUserId);
//
//        // 验证是群聊
//        validateGroupChat(chatRoom);
//
//        // 验证操作用户是否在群聊中
//        validateChatRoomAccess(chatRoom, user);
//
//        // 检查目标用户是否已在群聊中
//        if (chatRoom.getParticipants().contains(targetUser)) {
//            throw new ChatRoomException("用户已经在群聊中");
//        }
//
//        // 添加用户到群聊
//        chatRoom.getParticipants().add(targetUser);
//        ChatRoom updatedChatRoom = chatRoomRepository.save(chatRoom);
//
//        // 发送通知
//        notificationService.sendChatRoomActivityNotification(
//                updatedChatRoom, "JOIN", user, targetUser);
//
//        return updatedChatRoom;
//    }
//
//    /**
//     * 批量添加用户到群聊
//     */
//    @Transactional
//    public ChatRoom addParticipantsToGroupChat(Long chatRoomId, Long userId, List<Long> targetUserIds) {
//        ChatRoom chatRoom = getChatRoomById(chatRoomId);
//        User user = getUserById(userId);
//
//        // 验证是群聊
//        validateGroupChat(chatRoom);
//
//        // 验证操作用户是否在群聊中
//        validateChatRoomAccess(chatRoom, user);
//
//        // 逐个添加用户
//        for (Long targetUserId : targetUserIds) {
//            User targetUser = getUserById(targetUserId);
//
//            // 如果用户已在群聊中，跳过
//            if (chatRoom.getParticipants().contains(targetUser)) {
//                continue;
//            }
//
//            // 添加用户到群聊
//            chatRoom.getParticipants().add(targetUser);
//
//            // 发送通知
//            try {
//                notificationService.sendChatRoomActivityNotification(
//                        chatRoom, "JOIN", user, targetUser);
//            } catch (Exception e) {
//                log.error("发送群聊加入通知失败，用户ID: {}", targetUser.getId(), e);
//            }
//        }
//
//        return chatRoomRepository.save(chatRoom);
//    }
//
//    /**
//     * 从群聊中移除用户
//     */
//    @Transactional
//    public ChatRoom removeParticipantFromGroupChat(Long chatRoomId, Long userId, Long targetUserId) {
//        ChatRoom chatRoom = getChatRoomById(chatRoomId);
//        User user = getUserById(userId);
//        User targetUser = getUserById(targetUserId);
//
//        // 验证是群聊
//        validateGroupChat(chatRoom);
//
//        // 验证操作用户是否在群聊中
//        validateChatRoomAccess(chatRoom, user);
//
//        // 检查操作权限：只有创建者可以移除他人，或者用户移除自己
//        if (!userId.equals(targetUserId) && !chatRoom.getCreator().getId().equals(userId)) {
//            throw new ChatAccessDeniedException("没有权限从群聊中移除用户");
//        }
//
//        // 群主不能被移除
//        if (targetUser.getId().equals(chatRoom.getCreator().getId())) {
//            throw new ChatRoomException("群主不能被移除");
//        }
//
//        // 检查目标用户是否在群聊中
//        if (!chatRoom.getParticipants().contains(targetUser)) {
//            throw new ChatRoomException("用户不在群聊中");
//        }
//
//        // 移除用户
//        chatRoom.getParticipants().remove(targetUser);
//        ChatRoom updatedChatRoom = chatRoomRepository.save(chatRoom);
//
//        // 发送通知
//        String activityType = userId.equals(targetUserId) ? "LEAVE" : "REMOVE";
//        notificationService.sendChatRoomActivityNotification(
//                updatedChatRoom, activityType, user, targetUser);
//
//        return updatedChatRoom;
//    }
//
//    /**
//     * 更新群聊信息
//     */
//    @Transactional
//    public ChatRoom updateGroupChatInfo(Long chatRoomId, Long userId, String newGroupName, byte[] newGroupAvatar) {
//        ChatRoom chatRoom = getChatRoomById(chatRoomId);
//        User user = getUserById(userId);
//
//        // 验证是群聊
//        validateGroupChat(chatRoom);
//
//        // 验证操作用户是否在群聊中
//        validateChatRoomAccess(chatRoom, user);
//
//        // 验证用户是否是创建者
//        if (!chatRoom.getCreator().getId().equals(userId)) {
//            throw new ChatAccessDeniedException("只有群主可以修改群聊信息");
//        }
//
//        // 更新群名称（如果提供）
//        if (newGroupName != null && !newGroupName.trim().isEmpty()) {
//            chatRoom.setGroupName(newGroupName);
//        }
//
//        // 更新群头像（如果提供）
//        if (newGroupAvatar != null && newGroupAvatar.length > 0) {
//            try {
//                // 删除旧头像
//                if (chatRoom.getGroupAvatar() != null) {
//                    fileStorageService.deleteFile(chatRoom.getGroupAvatar());
//                }
//
//                // 保存新头像
//                String avatarUrl = fileStorageService.storeMediaFile(newGroupAvatar, "group_avatar.jpg", "image");
//                chatRoom.setGroupAvatar(avatarUrl);
//            } catch (Exception e) {
//                log.error("更新群头像失败", e);
//                // 继续更新群信息，但不更新头像
//            }
//        }
//
//        return chatRoomRepository.save(chatRoom);
//    }
//
//    /**
//     * 解散群聊
//     */
//    @Transactional
//    public void dissolveGroupChat(Long chatRoomId, Long userId) {
//        ChatRoom chatRoom = getChatRoomById(chatRoomId);
//        User user = getUserById(userId);
//
//        // 验证是群聊
//        validateGroupChat(chatRoom);
//
//        // 验证用户是否是创建者
//        if (!chatRoom.getCreator().getId().equals(userId)) {
//            throw new ChatAccessDeniedException("只有群主可以解散群聊");
//        }
//
//        // 保存参与者列表用于通知
//        Set<User> participants = new HashSet<>(chatRoom.getParticipants());
//
//        // 解散群聊（从数据库删除）
//        chatRoomRepository.delete(chatRoom);
//
//        // 通知所有参与者群聊已解散
//        for (User participant : participants) {
//            if (!participant.getId().equals(userId)) {
//                try {
//                    log.info("通知用户 {}：群聊 {} 已被解散", participant.getUsername(), chatRoom.getGroupName());
//                    // 实际应用中这里应该发送通知
//                } catch (Exception e) {
//                    log.error("发送群聊解散通知失败，用户ID: {}", participant.getId(), e);
//                }
//            }
//        }
//    }
//
//    /**
//     * 退出聊天室（私聊隐藏，群聊退出）
//     */
//    @Transactional
//    public void leaveChatRoom(Long chatRoomId, Long userId) {
//        ChatRoom chatRoom = getChatRoomById(chatRoomId);
//        User user = getUserById(userId);
//
//        // 验证用户是否在聊天室中
//        validateChatRoomAccess(chatRoom, user);
//
//        if (chatRoom.getChatType() == ChatRoom.ChatType.PRIVATE) {
//            // 私聊不能真正退出，实际应用中应标记为隐藏状态
//            log.info("用户 {} 隐藏了与 {} 的私聊", user.getUsername(),
//                    getOtherParticipant(chatRoom, user).getUsername());
//        } else {
//            // 如果是群聊
//            if (chatRoom.getCreator().getId().equals(userId)) {
//                // 如果是群主，不能直接退出
//                throw new ChatRoomException("群主不能直接退出群聊，请先转让群主或解散群聊");
//            }
//
//            // 执行退出操作
//            chatRoom.getParticipants().remove(user);
//            chatRoomRepository.save(chatRoom);
//
//            // 通知其他群成员
//            notificationService.sendChatRoomActivityNotification(
//                    chatRoom, "LEAVE", user, user);
//        }
//    }
//
//    /**
//     * 转让群主身份
//     */
//    @Transactional
//    public ChatRoom transferGroupOwnership(Long chatRoomId, Long currentOwnerId, Long newOwnerId) {
//        ChatRoom chatRoom = getChatRoomById(chatRoomId);
//        User currentOwner = getUserById(currentOwnerId);
//        User newOwner = getUserById(newOwnerId);
//
//        // 验证是群聊
//        validateGroupChat(chatRoom);
//
//        // 验证当前用户是否是群主
//        if (!chatRoom.getCreator().getId().equals(currentOwnerId)) {
//            throw new ChatAccessDeniedException("只有群主可以转让群主身份");
//        }
//
//        // 验证新群主是否在群聊中
//        if (!chatRoom.getParticipants().contains(newOwner)) {
//            throw new ChatRoomException("新群主不在群聊中");
//        }
//
//        // 转让群主身份
//        chatRoom.setCreator(newOwner);
//        ChatRoom updatedChatRoom = chatRoomRepository.save(chatRoom);
//
//        // 通知所有群成员
//        for (User participant : chatRoom.getParticipants()) {
//            if (!participant.getId().equals(currentOwnerId) && !participant.getId().equals(newOwnerId)) {
//                try {
//                    log.info("通知用户 {}：群聊 {} 的群主已从 {} 变更为 {}",
//                            participant.getUsername(),
//                            chatRoom.getGroupName(),
//                            currentOwner.getUsername(),
//                            newOwner.getUsername());
//                    // 实际应用中这里应该发送通知
//                } catch (Exception e) {
//                    log.error("发送群主变更通知失败，用户ID: {}", participant.getId(), e);
//                }
//            }
//        }
//
//        return updatedChatRoom;
//    }
//
//    /**
//     * 获取聊天室的所有参与者
//     */
//    public Set<User> getChatRoomParticipants(Long chatRoomId, Long userId) {
//        ChatRoom chatRoom = getChatRoomById(chatRoomId);
//        User user = getUserById(userId);
//
//        // 验证用户是否在聊天室中
//        validateChatRoomAccess(chatRoom, user);
//
//        return chatRoom.getParticipants();
//    }
//
//    /**
//     * 清除与某个用户的聊天记录（保留聊天室）
//     */
//    @Transactional
//    public void clearChatHistory(Long chatRoomId, Long userId) {
//        ChatRoom chatRoom = getChatRoomById(chatRoomId);
//        User user = getUserById(userId);
//
//        // 验证用户是否在聊天室中
//        validateChatRoomAccess(chatRoom, user);
//
//        // 获取聊天室中的所有消息
//        List<ChatMessage> messages = chatMessageRepository.findByChatRoomOrderByCreatedAtAsc(chatRoom);
//
//        // 找到用户的所有消息状态并标记为已删除
//        // 注意：实际实现中应该添加一个isDeleted字段到MessageReadStatus
//        for (ChatMessage message : messages) {
//            Optional<MessageReadStatus> readStatus = messageReadStatusRepository.findByMessageAndUser(message, user);
//            if (readStatus.isPresent()) {
//                // 这里假设MessageReadStatus有isDeleted字段
//                // readStatus.get().setIsDeleted(true);
//                // messageReadStatusRepository.save(readStatus.get());
//
//                // 由于现有模型没有isDeleted字段，这里只记录日志
//                log.info("用户 {} 删除了消息 {} 的历史记录", user.getUsername(), message.getId());
//            }
//        }
//
//        log.info("用户 {} 清除了聊天室 {} 的历史记录", user.getUsername(), chatRoom.getId());
//    }
//
//    /**
//     * 统计用户的聊天室数量
//     */
//    public Long countUserChatRooms(Long userId) {
//        User user = getUserById(userId);
//        return chatRoomRepository.countByParticipant(user);
//    }
//
//    /**
//     * 判断用户是否在聊天室中
//     */
//    public boolean isUserInChatRoom(Long chatRoomId, Long userId) {
//        ChatRoom chatRoom = chatRoomRepository.findById(chatRoomId)
//                .orElseThrow(() -> new EntityNotFoundException("聊天室不存在，ID: " + chatRoomId));
//
//        User user = getUserById(userId);
//
//        return chatRoom.getParticipants().contains(user);
//    }
//
//    /**
//     * 获取两个用户之间的私聊聊天室，如果不存在则创建
//     */
//    @Transactional
//    public ChatRoom getOrCreatePrivateChatRoom(Long user1Id, Long user2Id) {
//        User user1 = getUserById(user1Id);
//        User user2 = getUserById(user2Id);
//
//        // 检查是否已存在私聊聊天室
//        Optional<ChatRoom> existingChatRoom = chatRoomRepository.findOneOnOneChatRoom(user1, user2);
//        if (existingChatRoom.isPresent()) {
//            return existingChatRoom.get();
//        }
//
//        // 创建新的私聊聊天室
//        return createPrivateChatRoom(user1Id, user2Id);
//    }
//
//    /**
//     * 获取用户最近活跃的聊天室（基于最后一条消息时间）
//     */
//    public List<ChatRoom> getRecentActiveChats(Long userId, int limit) {
//        User user = getUserById(userId);
//
//        // 获取用户的所有聊天室
//        List<ChatRoom> allRooms = chatRoomRepository.findByParticipant(user);
//
//        // 按最后消息时间排序
//        // 注意：这里假设ChatRoom实体有lastMessageTime字段
//        // 实际实现中可能需要联表查询或其他方式获取最后消息时间
//
//        // 简化实现：此处只返回前limit个聊天室
//        return allRooms.stream().limit(limit).collect(Collectors.toList());
//    }
//
//    // 辅助方法
//
//    /**
//     * 获取私聊中的另一个参与者
//     */
//    private User getOtherParticipant(ChatRoom chatRoom, User currentUser) {
//        if (chatRoom.getChatType() != ChatRoom.ChatType.PRIVATE) {
//            throw new IllegalArgumentException("不是私聊聊天室");
//        }
//
//        return chatRoom.getParticipants().stream()
//                .filter(p -> !p.getId().equals(currentUser.getId()))
//                .findFirst()
//                .orElseThrow(() -> new IllegalStateException("私聊聊天室中找不到另一个参与者"));
//    }
//
//    /**
//     * 验证是否为群聊
//     */
//    private void validateGroupChat(ChatRoom chatRoom) {
//        if (chatRoom.getChatType() != ChatRoom.ChatType.GROUP) {
//            throw new ChatRoomException("此操作只适用于群聊");
//        }
//    }
//
//    /**
//     * 验证用户是否有权访问聊天室
//     */
//    private void validateChatRoomAccess(ChatRoom chatRoom, User user) {
//        if (!chatRoom.getParticipants().contains(user)) {
//            throw new ChatAccessDeniedException("用户不是聊天室的参与者");
//        }
//    }
//
//    /**
//     * 获取用户实体
//     */
//    private User getUserById(Long userId) {
//        return userRepository.findById(userId)
//                .orElseThrow(() -> new EntityNotFoundException("用户不存在，ID: " + userId));
//    }
//
//    /**
//     * 获取医生实体
//     */
//    private Doctor getDoctorById(Long doctorId) {
//        return doctorRepository.findById(doctorId)
//                .orElseThrow(() -> new EntityNotFoundException("医生不存在，ID: " + doctorId));
//    }
//
//    /**
//     * 获取患者实体
//     */
//    private Patient getPatientById(Long patientId) {
//        return patientRepository.findById(patientId)
//                .orElseThrow(() -> new EntityNotFoundException("患者不存在，ID: " + patientId));
//    }
//
//    /**
//     * 获取聊天室实体
//     */
//    private ChatRoom getChatRoomById(Long chatRoomId) {
//        return chatRoomRepository.findById(chatRoomId)
//                .orElseThrow(() -> new EntityNotFoundException("聊天室不存在，ID: " + chatRoomId));
//    }
//}